My plug-in system is influenced by Anthonys plug-in system used in Shade45s Engineer application.  It is obviously not the same though so I thought I would do a write up of some of how it works and point out some of the differences between them.
To create a plug-in for Excalibur you will need the basic template for a plugin:

using LazyIO;
namespace HaloMap
{
	[Plugin(Author, tagtype, 1.0)]		
	public class tagtype : Meta
	{
		// example layout
		Float Example_Float;
		Int Example_Int;
		Ident Example_Ident;
		Dependency Example_Dependency;
		[Size(24)]
		Unused Example_Unused; // size 24
		Reflexive<ExampleReflexiveChunk> Example_Reflexive;
		public class ExampleReflexiveChunk : Chunk
		{
			String32 Example_String32;
			Byte Example_Byte;
		}
	}
}

Allowed Attributes:
Plugin - used on the plugins to give information about them, [Plugin(author, tag type, version)]
author and tag type are strings, and version is a double
Description - use to add special remarks about something.  For example
[Description("in seconds")]
Int Spawn_Time;
[Description("radians")]
Float Rotation_Pitch;

In the meta editor the names would show up as
Spawn Time (in seconds)
Rotation Pitch (radians)

Visible - use if you want to make something invisible: [Visible(false)] will make it invisible, everything is assumed to be visible if it does not have this attribute
Size - can be used on String and Unused

As you can see, you dont have to declare anything as public(except the class definitions, for example the metas, chunks, bitmasks, and enum definitions)

Ill go through all of the allowable types now, they all start with an uppercase letter, and if you dont do that it wont give you an error but will cause your plug-in not to function correctly.

1 byte types:
Byte
BitMask8
Enum16

2 byte types
UShort
Short
BitMask16
Enum16

4 byte types
UInt
Int
Float
BitMask32
Enum32
Unkown
Ident
Dependency
StringID

8 byte types
Reflexive<ChunkType> - where ChunkType is a class that derives from chunk

string Types
String32
String64
Unicode64
Unicode256

Variable size types  Use a [Size(n)] attribute before these types(n being the number of bytes)
Unused
String


How to make a reflexive:

Reflexive<ExampleChunk> Example_Reflexive;
public class ExampleChunk : Chunk
{
 	Dependency Example_Dependency;
}

How to make a bitmask:

ExampleBitmask Example_Bitmask;
public class ExampleBitmask : BitMask16
{
 	protected override AddBits()
 	{
		AddBit(Bit 0, 0);
 		AddBit(Fire Once, 8);
 	}
}



How to make an enum:

ExampleEnum Example_Enum;
public class Example_Enum : Enum8
{
 	protected override AddOptions()
 	{
 		AddOption(Some Option, 12);
		AddOption(Another Option, 16);
 	}
}
